﻿using Algorithms;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.Collections.Generic;

namespace UnitTests
{
    
    
    /// <summary>
    ///This is a test class for LinearProbingHashSTTest and is intended
    ///to contain all LinearProbingHashSTTest Unit Tests
    ///</summary>
    [TestClass()]
    public class LinearProbingHashSTTest
    {


        private TestContext testContextInstance;

        /// <summary>
        ///Gets or sets the test context which provides
        ///information about and functionality for the current test run.
        ///</summary>
        public TestContext TestContext
        {
            get
            {
                return testContextInstance;
            }
            set
            {
                testContextInstance = value;
            }
        }

        #region Additional test attributes
        // 
        //You can use the following additional attributes as you write your tests:
        //
        //Use ClassInitialize to run code before running the first test in the class
        //[ClassInitialize()]
        //public static void MyClassInitialize(TestContext testContext)
        //{
        //}
        //
        //Use ClassCleanup to run code after all tests in a class have run
        //[ClassCleanup()]
        //public static void MyClassCleanup()
        //{
        //}
        //
        //Use TestInitialize to run code before running each test
        //[TestInitialize()]
        //public void MyTestInitialize()
        //{
        //}
        //
        //Use TestCleanup to run code after each test has run
        //[TestCleanup()]
        //public void MyTestCleanup()
        //{
        //}
        //
        #endregion


        /// <summary>
        ///A test for LinearProbingHashST`2 Constructor
        ///</summary>
        public void LinearProbingHashSTConstructorTestHelper<Key, Value>()
            where Key : IComparable
        {
            int capacity = 0; // TODO: Initialize to an appropriate value
            bool canResize = false; // TODO: Initialize to an appropriate value
            Dictionary<Key, int> hashMap = null; // TODO: Initialize to an appropriate value
            LinearProbingHashST<Key, Value> target = new LinearProbingHashST<Key, Value>(capacity, canResize, hashMap);
            Assert.Inconclusive("TODO: Implement code to verify target");
        }

        [TestMethod()]
        public void LinearProbingHashSTConstructorTest()
        {
            LinearProbingHashSTConstructorTestHelper<GenericParameterHelper, GenericParameterHelper>();
        }

        /// <summary>
        ///A test for LinearProbingHashST`2 Constructor
        ///</summary>
        public void LinearProbingHashSTConstructorTest1Helper<Key, Value>()
            where Key : IComparable
        {
            int capacity = 0; // TODO: Initialize to an appropriate value
            bool canResize = false; // TODO: Initialize to an appropriate value
            LinearProbingHashST<Key, Value> target = new LinearProbingHashST<Key, Value>(capacity, canResize);
            Assert.Inconclusive("TODO: Implement code to verify target");
        }

        [TestMethod()]
        public void LinearProbingHashSTConstructorTest1()
        {
            LinearProbingHashSTConstructorTest1Helper<GenericParameterHelper, GenericParameterHelper>();
        }

        /// <summary>
        ///A test for LinearProbingHashST`2 Constructor
        ///</summary>
        public void LinearProbingHashSTConstructorTest2Helper<Key, Value>()
            where Key : IComparable
        {
            LinearProbingHashST<Key, Value> target = new LinearProbingHashST<Key, Value>();
            Assert.Inconclusive("TODO: Implement code to verify target");
        }

        [TestMethod()]
        public void LinearProbingHashSTConstructorTest2()
        {
            LinearProbingHashSTConstructorTest2Helper<GenericParameterHelper, GenericParameterHelper>();
        }

        /// <summary>
        ///A test for Check
        ///</summary>
        public void CheckTestHelper<Key, Value>()
            where Key : IComparable
        {
            LinearProbingHashST_Accessor<Key, Value> target = new LinearProbingHashST_Accessor<Key, Value>(); // TODO: Initialize to an appropriate value
            bool expected = false; // TODO: Initialize to an appropriate value
            bool actual;
            actual = target.Check();
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        [TestMethod()]
        [DeploymentItem("Algorithms.exe")]
        public void CheckTest()
        {
            CheckTestHelper<GenericParameterHelper, GenericParameterHelper>();
        }

        /// <summary>
        ///A test for Contains
        ///</summary>
        public void ContainsTestHelper<Key, Value>()
            where Key : IComparable
        {
            LinearProbingHashST<Key, Value> target = new LinearProbingHashST<Key, Value>(); // TODO: Initialize to an appropriate value
            Key key = default(Key); // TODO: Initialize to an appropriate value
            bool expected = false; // TODO: Initialize to an appropriate value
            bool actual;
            actual = target.Contains(key);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        [TestMethod()]
        public void ContainsTest()
        {
            ContainsTestHelper<GenericParameterHelper, GenericParameterHelper>();
        }

        /// <summary>
        ///A test for Delete
        ///</summary>
        public void DeleteTestHelper<Key, Value>()
            where Key : IComparable
        {
            LinearProbingHashST<Key, Value> target = new LinearProbingHashST<Key, Value>(); // TODO: Initialize to an appropriate value
            Key key = default(Key); // TODO: Initialize to an appropriate value
            target.Delete(key);
            Assert.Inconclusive("A method that does not return a value cannot be verified.");
        }

        [TestMethod()]
        public void DeleteTest()
        {
            DeleteTestHelper<GenericParameterHelper, GenericParameterHelper>();
        }

        /// <summary>
        ///A test for GetValue
        ///</summary>
        public void GetValueTestHelper<Key, Value>()
            where Key : IComparable
        {
            LinearProbingHashST<Key, Value> target = new LinearProbingHashST<Key, Value>(); // TODO: Initialize to an appropriate value
            Key key = default(Key); // TODO: Initialize to an appropriate value
            Value expected = default(Value); // TODO: Initialize to an appropriate value
            Value actual;
            actual = target.GetValue(key);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        [TestMethod()]
        public void GetValueTest()
        {
            GetValueTestHelper<GenericParameterHelper, GenericParameterHelper>();
        }

        /// <summary>
        ///A test for Keys
        ///</summary>
        public void KeysTestHelper<Key, Value>()
            where Key : IComparable
        {
            LinearProbingHashST<Key, Value> target = new LinearProbingHashST<Key, Value>(); // TODO: Initialize to an appropriate value
            IEnumerable<Key> expected = null; // TODO: Initialize to an appropriate value
            IEnumerable<Key> actual;
            actual = target.Keys();
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        [TestMethod()]
        public void KeysTest()
        {
            KeysTestHelper<GenericParameterHelper, GenericParameterHelper>();
        }

        /// <summary>
        ///A test for Put
        ///</summary>
        public void PutTestHelper<Key, Value>()
            where Key : IComparable
        {
            LinearProbingHashST<Key, Value> target = new LinearProbingHashST<Key, Value>(); // TODO: Initialize to an appropriate value
            Key key = default(Key); // TODO: Initialize to an appropriate value
            Value val = default(Value); // TODO: Initialize to an appropriate value
            target.Put(key, val);
            Assert.Inconclusive("A method that does not return a value cannot be verified.");
        }

        [TestMethod()]
        public void PutTest()
        {
            PutTestHelper<GenericParameterHelper, GenericParameterHelper>();
        }

        /// <summary>
        ///A test for Resize
        ///</summary>
        public void ResizeTestHelper<Key, Value>()
            where Key : IComparable
        {
            LinearProbingHashST_Accessor<Key, Value> target = new LinearProbingHashST_Accessor<Key, Value>(); // TODO: Initialize to an appropriate value
            int capacity = 0; // TODO: Initialize to an appropriate value
            target.Resize(capacity);
            Assert.Inconclusive("A method that does not return a value cannot be verified.");
        }

        [TestMethod()]
        [DeploymentItem("Algorithms.exe")]
        public void ResizeTest()
        {
            ResizeTestHelper<GenericParameterHelper, GenericParameterHelper>();
        }

        /// <summary>
        ///A test for ToString
        ///</summary>
        public void ToStringTestHelper<Key, Value>()
            where Key : IComparable
        {
            LinearProbingHashST<Key, Value> target = new LinearProbingHashST<Key, Value>(); // TODO: Initialize to an appropriate value
            string expected = string.Empty; // TODO: Initialize to an appropriate value
            string actual;
            actual = target.ToString();
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        [TestMethod()]
        public void ToStringTest()
        {
            ToStringTestHelper<GenericParameterHelper, GenericParameterHelper>();
        }

        /// <summary>
        ///A test for hash
        ///</summary>
        public void hashTestHelper<Key, Value>()
            where Key : IComparable
        {
            LinearProbingHashST_Accessor<Key, Value> target = new LinearProbingHashST_Accessor<Key, Value>(); // TODO: Initialize to an appropriate value
            Key key = default(Key); // TODO: Initialize to an appropriate value
            int expected = 0; // TODO: Initialize to an appropriate value
            int actual;
            actual = target.hash(key);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        [TestMethod()]
        [DeploymentItem("Algorithms.exe")]
        public void hashTest()
        {
            hashTestHelper<GenericParameterHelper, GenericParameterHelper>();
        }

        /// <summary>
        ///A test for Count
        ///</summary>
        public void CountTestHelper<Key, Value>()
            where Key : IComparable
        {
            LinearProbingHashST<Key, Value> target = new LinearProbingHashST<Key, Value>(); // TODO: Initialize to an appropriate value
            int actual;
            actual = target.Count;
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        [TestMethod()]
        public void CountTest()
        {
            CountTestHelper<GenericParameterHelper, GenericParameterHelper>();
        }

        /// <summary>
        ///A test for IsEmpty
        ///</summary>
        public void IsEmptyTestHelper<Key, Value>()
            where Key : IComparable
        {
            LinearProbingHashST<Key, Value> target = new LinearProbingHashST<Key, Value>(); // TODO: Initialize to an appropriate value
            bool actual;
            actual = target.IsEmpty;
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        [TestMethod()]
        public void IsEmptyTest()
        {
            IsEmptyTestHelper<GenericParameterHelper, GenericParameterHelper>();
        }
    }
}
